home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / PROGENV / MethodB.C < prev    next >
C/C++ Source or Header  |  1992-07-02  |  8KB  |  332 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "MethodB.h"
  6.  
  7. #include "ET++.h"
  8.  
  9. #include "OrdColl.h"
  10. #include "RegularExp.h"
  11. #include "ClassManager.h"
  12. #include "System.h"
  13. #include "Buttons.h"
  14. #include "Fields.h"
  15. #include "ManyOfCluster.h"
  16. #include "BorderItems.h"
  17.  
  18. #include "EtPeCmdNo.h"
  19. #include "EtPeManager.h"
  20.   
  21. static PeMethodFilterDialog *filter;
  22.  
  23. //---- PeMethodItem -----------------------------------------------------------
  24.  
  25. NewMetaImpl(PeMethodItem, TextItem, (TP(cl), TP(mrp)));
  26.  
  27. PeMethodItem::PeMethodItem(PeMethodReference *m, char *label) 
  28.                 : TextItem(cIdNone, label, gFixedFont, Point(2,1))
  29. {
  30.     mrp= m;
  31. }
  32.  
  33. PeMethodItem::PeMethodItem(Class *cp)
  34.         : TextItem(cIdNone, 0, gFixedFont->WithFace(eFaceBold), Point(2,1))
  35. {
  36.     mrp= 0;
  37.     cl= cp;
  38.     SetFString(FALSE, "Class: %s", cp->Name());
  39. }
  40.  
  41. int PeMethodItem::Line()
  42. { 
  43.     return mrp->Line(); 
  44. }
  45.  
  46. Class *PeMethodItem::GetClass()
  47. { 
  48.     return mrp ? mrp->GetClass() : 0; 
  49. }
  50.  
  51. bool PeMethodItem::IsPublic()
  52. {   
  53.     return mrp->IsPublic(); 
  54. }
  55.  
  56. //---- PeMethodBrowser -----------------------------------------------------------
  57.  
  58. NewMetaImpl(PeMethodBrowser, CollectionView, 
  59.                 (TP(allMethods), TP(filteredMethods), TP(ofClass)));
  60.  
  61. PeMethodBrowser::PeMethodBrowser(EvtHandler *b) 
  62.                     : CollectionView(b, 0, eCVDontStuckToBorder)
  63. {
  64.     allMethods= filteredMethods= 0;
  65.     ofClass= 0;
  66.     SetMinExtent(Point(250, 0));
  67. }
  68.  
  69. PeMethodBrowser::~PeMethodBrowser()
  70. {
  71.     if (allMethods) {
  72.     allMethods->FreeAll();
  73.     SafeDelete(allMethods);
  74.     }
  75. }
  76.  
  77. static Object *AsMethodItem(Object*, Object *op, void*)
  78. {
  79.     PeMethodReference *mr= (PeMethodReference*)op;
  80.     return new PeMethodItem(mr, (char*) mr->Str());
  81. }
  82.  
  83. void PeMethodBrowser::ShowMethodsOf(Class* cp)
  84. {
  85.     SeqCollection *oc= 0, *methodsOfClass;
  86.     
  87.     if (cp != 0) {
  88.     oc= new OrdCollection;
  89.     ofClass= cp;
  90.     for (Class *cl= cp; cl != 0; cl= cl->Super()) {
  91.         oc->Add(new PeMethodItem(cl));
  92.         SeqCollection *methods= 
  93.         Guard(gEtPeManager->LoadMethodsOfClass(cl), SeqCollection);
  94.         if (methods) {
  95.         methodsOfClass= (SeqCollection *) methods->Collect(AsMethodItem);
  96.         oc->AddAll(methodsOfClass);
  97.         SafeDelete(methodsOfClass);
  98.         }
  99.     }
  100.     }
  101.     if (allMethods)
  102.     allMethods->FreeAll();
  103.     SafeDelete(allMethods);
  104.     allMethods= oc;
  105.     SetCollection(allMethods, FALSE);
  106.     UpdateEvent();
  107. }
  108.  
  109. void PeMethodBrowser::SelectMethod(PeMethodReference *mr)
  110. {
  111.     PeMethodItem *mi;
  112.     Iter next(GetCollection());
  113.     for (int i= 0; (mi= (PeMethodItem*)next()) != 0; i++) {
  114.     if (mi->mrp && mr->IsEqual(mi->mrp)) {
  115.         Rectangle sr= Rectangle(0, i, 1, 1);
  116.         SetSelection(sr);
  117.         Rectangle r= ItemRect(sr);
  118.         RevealAlign(r);
  119.         return;
  120.     }
  121.     }
  122. }
  123.  
  124. class PeMethodItem *PeMethodBrowser::GetSelectedMethod()
  125. {
  126.     SeqCollection *col= GetCollection();
  127.     if (GetSelection().IsEmpty())
  128.     return 0;
  129.     int at= GetSelection().origin.y;
  130.     PeMethodItem *mi= Guard(col->At(at), PeMethodItem);
  131.     return mi;
  132. }
  133.  
  134. void PeMethodBrowser::DoSelect(Rectangle, int)
  135. {
  136.     PeMethodItem *mi= GetSelectedMethod();
  137.     if (mi == 0)
  138.     return;
  139.     if (mi->mrp != 0) 
  140.     Control(cPeMethodBrowser, cPeChangedMethod, mi->mrp); 
  141.     else {   
  142.     Control(cPeMethodBrowser, cPeCLChangedClass, mi->cl);
  143.     ClearSelection();
  144.     }
  145. }
  146.  
  147. void PeMethodBrowser::Filter()
  148. {
  149.     if (filter == 0)
  150.     filter= new PeMethodFilterDialog();
  151.     if (filter->ShowOnWindow(GetWindow()) == cIdYes) {
  152.     SeqCollection *fp= filter->DoIt(allMethods);
  153.     if (fp == 0)
  154.         return;
  155.     SetCollection(fp, FALSE);
  156.     UpdateEvent();
  157.     SafeDelete(filteredMethods);
  158.     filteredMethods= fp;    
  159.     }
  160. }
  161.  
  162. void PeMethodBrowser::RemoveFilter()
  163. {
  164.     if (filteredMethods != 0) {
  165.     SetCollection(allMethods, FALSE);
  166.     SafeDelete(filteredMethods);
  167.     UpdateEvent();
  168.     }
  169. }
  170.  
  171. //---- Implementors -------------------------------------------------------
  172.  
  173. NewMetaImpl0(PeImplementors, CollectionView);
  174.  
  175. PeImplementors::PeImplementors(EvtHandler *b) : CollectionView(b, 0)
  176. {
  177. }
  178.  
  179. void PeImplementors::ShowImplementorsOf(PeMethodReference *mrp, bool subClassesOnly)
  180. {
  181.     SeqCollection *oc= new OrdCollection;
  182.     Class *cl, *acl= mrp->GetClass();
  183.     char *method= (char*)mrp->Str();
  184.     
  185.     Iter next(gClassManager->Iterator());
  186.     while (cl= (Class*)next()) {
  187.     if (subClassesOnly && !(cl->isKindOf(acl) && cl != acl))
  188.         continue;
  189.     Collection *methods= gEtPeManager->LoadMethodsOfClass(cl);
  190.     if (methods) {
  191.         Iter next1(methods);
  192.         PeMethodReference *mr;
  193.         while (mr= (PeMethodReference*)next1()) {
  194.         if (gEtPeManager->SameMethods((char*)mr->Str(), method)) 
  195.             oc->Add(new PeMethodItem(mr, form("%s::%s", cl->Name(), method)));
  196.         else if (gEtPeManager->IsDestructor(method) && gEtPeManager->IsDestructor((char*)mr->Str()))
  197.             oc->Add(new PeMethodItem(mr, form("%s::~%s", cl->Name(), cl->Name())));
  198.         }
  199.     }
  200.     }
  201.     SetCollection(oc);
  202.     UpdateEvent();
  203. }
  204.  
  205. void PeImplementors::ShowInherited(PeMethodReference *mrp)
  206. {
  207.     SeqCollection *oc= new OrdCollection;
  208.     Class *cl, *ofClass= mrp->GetClass();
  209.     char *methodName= (char*)mrp->Str();
  210.     cl= ofClass->Super();
  211.  
  212.     for (; cl != 0; cl= cl->Super()) {
  213.     Collection *methods= cl->GetMethods();
  214.     if (methods == 0) {
  215.         methods= gEtPeManager->LoadMethodsOfClass(cl);
  216.         cl->SetMethods(methods);
  217.     }
  218.     Iter next1(methods);
  219.     PeMethodReference *mr;
  220.     while (mr= (PeMethodReference*)next1()) {
  221.         if (gEtPeManager->SameMethods((char*)mr->Str(), methodName)) 
  222.         oc->Add(new PeMethodItem(mr, form("%s::%s", cl->Name(), methodName)));
  223.         else if (gEtPeManager->IsDestructor(methodName) && gEtPeManager->IsDestructor((char*)mr->Str()))
  224.         oc->Add(new PeMethodItem(mr, form("%s::~%s", cl->Name(), cl->Name())));
  225.     }
  226.     }
  227.     SetCollection(oc);
  228.     UpdateEvent();
  229. }
  230.  
  231. void PeImplementors::DoSelect(Rectangle, int)
  232. {
  233.     SeqCollection *col= GetCollection();
  234.     int at= GetSelection().origin.y;
  235.     PeMethodItem *mi= Guard(col->At(at), PeMethodItem);
  236.     Control(cPeMethodBrowser, cPeChangedMethod, mi->mrp);
  237.     ClearSelection();    
  238. }
  239.  
  240. //---- PeMethodFilterDialog ----------------------------------------------------
  241.  
  242. PeMethodFilterDialog::PeMethodFilterDialog() : Dialog("Method Filter")
  243. {
  244.     rex= new RegularExp;
  245.     hidePublic= hidePrivate= hideProtected= FALSE;    
  246. }
  247.  
  248. VObject *PeMethodFilterDialog::DoMakeContent()
  249. {
  250.     return
  251.     new Matte( 
  252.         new VExpander(gPoint8,
  253.         new TextItem("Filter (regular expression):"),
  254.         pattern= new TextField(cIdFilter, 20),
  255.         new BorderItem("Hide",
  256.             new ManyOfCluster(cIdVisibility, eVObjVBase, gPoint4,
  257.             "public",
  258.             "protected",
  259.             "private",
  260.             0
  261.             )
  262.         ),
  263.         new HBox(Point(20), (VObjAlign)(eVObjVBase|eVObjHEqual),
  264.             new ActionButton(cIdYes, "Apply Filter", TRUE),
  265.             new ActionButton(cIdCancel, "Cancel"),
  266.             0
  267.         ),
  268.         0
  269.         )
  270.     );
  271. }
  272.  
  273. void PeMethodFilterDialog::Control(int id, int p, void *v)
  274. {
  275.     switch (id) {
  276.     
  277.     case cIdVisibility:
  278.     switch(p) {
  279.     case cIdVisibility:
  280.         hidePublic= !hidePublic;
  281.         break;
  282.     case cIdVisibility+1:
  283.         hideProtected= !hideProtected;
  284.         break;
  285.     case cIdVisibility+2:
  286.         hidePrivate= !hidePrivate;
  287.         break;
  288.     }
  289.     break;
  290.      
  291.     default:
  292.     Dialog::Control(id, p, v);
  293.     } 
  294. }
  295.  
  296. SeqCollection *PeMethodFilterDialog::DoIt(Collection *allMethods)
  297. {
  298.     PeMethodItem *mi;
  299.     bool matchAll= FALSE;
  300.     char pat[1000];
  301.     
  302.     pattern->GetString(pat, sizeof pat);
  303.     if (strlen(pat) == 0) 
  304.     matchAll= TRUE;
  305.     else {
  306.     rex->Reset(pat, TRUE);
  307.     if (rex->GetExprState()) {
  308.         ShowAlert(eAlertNote, rex->GetExprState());
  309.         return 0;
  310.     }
  311.     }
  312.     SeqCollection *filteredMethods= new OrdCollection;
  313.     Iter next(allMethods);
  314.     while (mi= (PeMethodItem *)next()) {
  315.     int n, match= 0;
  316.     if (mi->GetClass() == 0) {
  317.         filteredMethods->Add(mi);
  318.         continue;
  319.     }
  320.     if (!matchAll)
  321.         match= rex->SearchForward(mi->AsString(), &n);
  322.     if (matchAll || match != -1) {
  323.         if (mi->IsPublic() && !hidePublic)
  324.         filteredMethods->Add(mi);
  325.         if (!mi->IsPublic() && !hidePrivate)
  326.         filteredMethods->Add(mi);
  327.     }
  328.     }
  329.     return filteredMethods;
  330. }
  331.  
  332.